home *** CD-ROM | disk | FTP | other *** search
/ All for Cell Phones: Sony Ericsson / Sony-Ericsson 2004.iso / Java / Eval / eval.jar / eval / MyDecimal.class (.txt) < prev    next >
Encoding:
Java Class File  |  2002-06-13  |  6.7 KB  |  471 lines
  1. package eval;
  2.  
  3. public class MyDecimal {
  4.    private static final String PI_STR = "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110";
  5.    private static final boolean POSITIVE = false;
  6.    private static final boolean NEGATIVE = true;
  7.    private static int precision = 20;
  8.    private byte[] val;
  9.    private int ndot;
  10.    private int len;
  11.    private boolean negative;
  12.  
  13.    public MyDecimal() {
  14.       this.ndot = this.len = 0;
  15.       this.negative = false;
  16.    }
  17.  
  18.    public MyDecimal(MyDecimal var1) {
  19.       this.ndot = var1.ndot;
  20.       this.len = var1.len;
  21.       this.negative = var1.negative;
  22.       this.val = null;
  23.       if (this.len > 0) {
  24.          this.val = new byte[this.len];
  25.          System.arraycopy(var1.val, 0, this.val, 0, this.len);
  26.       }
  27.  
  28.    }
  29.  
  30.    public MyDecimal(String var1) {
  31.       int var2 = var1.length();
  32.       byte[] var3 = var1.getBytes();
  33.       this.ndot = var1.indexOf(46);
  34.       if (this.ndot >= 0) {
  35.          --var2;
  36.          System.arraycopy(var3, this.ndot + 1, var3, this.ndot, var2 - this.ndot);
  37.       } else {
  38.          this.ndot = var2;
  39.       }
  40.  
  41.       this.negative = false;
  42.       if (var3[0] == 45) {
  43.          this.negative = true;
  44.          --var2;
  45.          --this.ndot;
  46.          System.arraycopy(var3, 1, var3, 0, var2);
  47.       }
  48.  
  49.       this.val = new byte[var2];
  50.  
  51.       for(int var4 = 0; var4 < var2; ++var4) {
  52.          byte var5 = var3[var4];
  53.          this.val[var4] = (byte)(var5 - 48);
  54.       }
  55.  
  56.       this.len = var2;
  57.    }
  58.  
  59.    private MyDecimal(byte[] var1, int var2, int var3, boolean var4) {
  60.       this.val = new byte[var2];
  61.       System.arraycopy(var1, 0, this.val, 0, var2);
  62.       this.len = var2;
  63.       this.ndot = var3;
  64.       this.negative = var4;
  65.    }
  66.  
  67.    // $FF: renamed from: PI () eval.MyDecimal
  68.    public static MyDecimal method_0() {
  69.       return new MyDecimal("3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110".substring(0, precision + 2));
  70.    }
  71.  
  72.    public MyDecimal abs() {
  73.       MyDecimal var1 = new MyDecimal(this);
  74.       var1.negative = false;
  75.       return var1;
  76.    }
  77.  
  78.    public MyDecimal add(MyDecimal var1) {
  79.       if (this.negative == var1.negative) {
  80.          return this.add0(var1, this.negative);
  81.       } else if (this.greater0(var1)) {
  82.          return this.sub0(var1, this.negative);
  83.       } else {
  84.          MyDecimal var2 = var1.sub0(this, var1.negative);
  85.          return var2;
  86.       }
  87.    }
  88.  
  89.    private MyDecimal add0(MyDecimal var1, boolean var2) {
  90.       byte var3 = 0;
  91.       int var4 = this.ndot > var1.ndot ? this.ndot : var1.ndot;
  92.       int var5 = this.len - this.ndot > var1.len - var1.ndot ? this.len - this.ndot : var1.len - var1.ndot;
  93.       ++var4;
  94.       int var6 = var4 + var5;
  95.       this.normalize2(var4, var6);
  96.       var1.normalize2(var4, var6);
  97.       byte[] var7 = new byte[var6];
  98.  
  99.       for(int var8 = var6 - 1; var8 >= 0; --var8) {
  100.          var3 = (byte)(var3 + this.val[var8] + var1.val[var8]);
  101.          var7[var8] = (byte)(var3 % 10);
  102.          var3 = (byte)(var3 / 10);
  103.       }
  104.  
  105.       return new MyDecimal(var7, var6, var4, var2);
  106.    }
  107.  
  108.    private void addRight(byte var1, boolean var2) {
  109.       byte[] var3 = new byte[this.len + 1];
  110.       if (this.len != 0) {
  111.          System.arraycopy(this.val, 0, var3, 0, this.len);
  112.       }
  113.  
  114.       var3[this.len++] = var1;
  115.       if (!var2) {
  116.          ++this.ndot;
  117.       }
  118.  
  119.       this.val = var3;
  120.    }
  121.  
  122.    public MyDecimal beforePoint() {
  123.       return new MyDecimal(this.val, this.ndot, this.ndot, this.negative);
  124.    }
  125.  
  126.    public MyDecimal cos() {
  127.       MyDecimal var1 = this.normalizeToPrecision().mod2PI();
  128.       MyDecimal var2 = new MyDecimal("1");
  129.       MyDecimal var3 = getDelta(precision);
  130.       MyDecimal var5 = new MyDecimal("1");
  131.       MyDecimal var6 = var1.multiply(var1);
  132.       MyDecimal var7 = new MyDecimal("1");
  133.       boolean var8 = true;
  134.       int var9 = 2;
  135.  
  136.       MyDecimal var4;
  137.       try {
  138.          do {
  139.             var5 = var5.multiply(var6);
  140.             var7 = var7.multiply(new MyDecimal(Integer.toString(var9 - 1))).multiply(new MyDecimal(Integer.toString(var9)));
  141.             var4 = var5.divide(var7);
  142.             var4.negative = var8;
  143.             var2 = var2.add(var4);
  144.             var8 ^= true;
  145.             var9 += 2;
  146.          } while(var4.greater0(var3));
  147.       } catch (Exception var10) {
  148.       }
  149.  
  150.       return var2;
  151.    }
  152.  
  153.    public MyDecimal divide(MyDecimal var1) throws MyDecimalException {
  154.       if (var1.isZero()) {
  155.          throw new MyDecimalException("divide by zero");
  156.       } else {
  157.          MyDecimal var3 = new MyDecimal();
  158.          MyDecimal var4 = new MyDecimal();
  159.          boolean var6 = false;
  160.          int var7 = this.len - this.ndot > var1.len - var1.ndot ? this.len - this.ndot : var1.len - var1.ndot;
  161.          MyDecimal var2 = this.shift(var7);
  162.  
  163.          boolean var5;
  164.          MyDecimal var9;
  165.          for(var1 = var1.shift(var7); !(var5 = var2.isZero() && var2.ndot <= 0) || !var3.isZero() && var4.len - var4.ndot < precision; var3 = var3.sub0(var9, false)) {
  166.             if (var5 && var2.ndot <= 0) {
  167.                var3.addRight((byte)0, false);
  168.                var6 = true;
  169.             } else {
  170.                var3.addRight(var2.val[0], false);
  171.                var2.removeLeft(1);
  172.             }
  173.  
  174.             byte var8 = 0;
  175.             var9 = new MyDecimal();
  176.  
  177.             for(MyDecimal var10 = new MyDecimal(var1); !var10.greater0(var3); ++var8) {
  178.                var9 = var10;
  179.                var10 = var10.add0(var1, false);
  180.             }
  181.  
  182.             var4.addRight(var8, var6);
  183.          }
  184.  
  185.          var4.negative = this.negative != var1.negative;
  186.          return var4;
  187.       }
  188.    }
  189.  
  190.    public static MyDecimal getDelta(int var0) {
  191.       byte[] var1 = new byte[var0];
  192.  
  193.       for(int var2 = 0; var2 < var0; ++var2) {
  194.          var1[var2] = 0;
  195.       }
  196.  
  197.       var1[var0 - 1] = 1;
  198.       return new MyDecimal(var1, var0, 0, false);
  199.    }
  200.  
  201.    public static int getPrecision() {
  202.       return precision;
  203.    }
  204.  
  205.    private boolean greater0(MyDecimal var1) {
  206.       this.normalize();
  207.       var1.normalize();
  208.       if (this.ndot > var1.ndot) {
  209.          return true;
  210.       } else if (this.ndot < var1.ndot) {
  211.          return false;
  212.       } else {
  213.          for(int var2 = 0; var2 < this.len; ++var2) {
  214.             if (var2 >= this.len) {
  215.                return true;
  216.             }
  217.  
  218.             if (this.val[var2] > var1.val[var2]) {
  219.                return true;
  220.             }
  221.  
  222.             if (this.val[var2] < var1.val[var2]) {
  223.                return false;
  224.             }
  225.          }
  226.  
  227.          return false;
  228.       }
  229.    }
  230.  
  231.    public boolean isZero() {
  232.       for(int var1 = 0; var1 < this.len; ++var1) {
  233.          if (this.val[var1] != 0) {
  234.             return false;
  235.          }
  236.       }
  237.  
  238.       return true;
  239.    }
  240.  
  241.    public MyDecimal mod(MyDecimal var1) throws MyDecimalException {
  242.       MyDecimal var2 = this.divide(var1).beforePoint();
  243.       var2 = var1.multiply(var2);
  244.       var2 = this.subtract(var2);
  245.       return var2;
  246.    }
  247.  
  248.    private MyDecimal mod2PI() {
  249.       MyDecimal var1 = new MyDecimal();
  250.  
  251.       try {
  252.          var1 = this.mod(method_0().multiply1((byte)2));
  253.       } catch (MyDecimalException var2) {
  254.       }
  255.  
  256.       return var1;
  257.    }
  258.  
  259.    public MyDecimal multiply(MyDecimal var1) {
  260.       MyDecimal var2 = new MyDecimal();
  261.       boolean var3 = this.negative != var1.negative;
  262.  
  263.       for(int var4 = this.len - 1; var4 >= 0; --var4) {
  264.          var2 = var2.add0(var1.multiply1(this.val[var4]).shift(this.len - 1 - var4), var3);
  265.       }
  266.  
  267.       var2.ndot = var2.len - (this.len - this.ndot + var1.len - var1.ndot);
  268.       return var2;
  269.    }
  270.  
  271.    private MyDecimal multiply1(byte var1) {
  272.       byte var2 = 0;
  273.       byte[] var3 = new byte[this.len + 1];
  274.  
  275.       for(int var4 = this.len - 1; var4 >= 0; --var4) {
  276.          var2 = (byte)(var2 + this.val[var4] * var1);
  277.          var3[var4 + 1] = (byte)(var2 % 10);
  278.          var2 = (byte)(var2 / 10);
  279.       }
  280.  
  281.       var3[0] = var2;
  282.       MyDecimal var5 = new MyDecimal(var3, this.len + 1, this.ndot + 1, this.negative);
  283.       return var5;
  284.    }
  285.  
  286.    private void normalize() {
  287.       if (this.len != 0) {
  288.          if (this.len > this.ndot && this.val[this.len - 1] == 0) {
  289.             do {
  290.                --this.len;
  291.             } while(this.len > this.ndot && this.val[this.len - 1] == 0);
  292.          }
  293.  
  294.          while(this.ndot > 0 && this.val[0] == 0) {
  295.             --this.len;
  296.             --this.ndot;
  297.             System.arraycopy(this.val, 1, this.val, 0, this.len);
  298.          }
  299.  
  300.       }
  301.    }
  302.  
  303.    private void normalize2(int var1, int var2) {
  304.       byte[] var3 = new byte[var2];
  305.  
  306.       for(int var4 = 0; var4 < var2; ++var4) {
  307.          var3[var4] = 0;
  308.       }
  309.  
  310.       if (this.len != 0) {
  311.          System.arraycopy(this.val, 0, var3, var1 - this.ndot, this.len);
  312.       }
  313.  
  314.       this.val = var3;
  315.       this.ndot = var1;
  316.       this.len = var2;
  317.    }
  318.  
  319.    public MyDecimal normalizeToPrecision() {
  320.       int var1 = this.len - this.ndot - precision;
  321.       MyDecimal var2;
  322.       if (var1 > 0) {
  323.          var2 = new MyDecimal(this.val, this.len - var1, this.ndot, this.negative);
  324.       } else {
  325.          var2 = new MyDecimal(this);
  326.       }
  327.  
  328.       return var2;
  329.    }
  330.  
  331.    public MyDecimal power(int var1) {
  332.       if (var1 <= 0) {
  333.          return new MyDecimal("1");
  334.       } else {
  335.          MyDecimal var2 = new MyDecimal(this);
  336.  
  337.          while(true) {
  338.             --var1;
  339.             if (var1 <= 0) {
  340.                return var2;
  341.             }
  342.  
  343.             var2 = var2.multiply(this);
  344.          }
  345.       }
  346.    }
  347.  
  348.    private void removeLeft(int var1) {
  349.       this.len -= var1;
  350.       this.ndot -= var1;
  351.       if (this.len > 0) {
  352.          byte[] var2 = new byte[this.len];
  353.          System.arraycopy(this.val, var1, var2, 0, this.len);
  354.          this.val = var2;
  355.       } else {
  356.          this.val = null;
  357.       }
  358.  
  359.    }
  360.  
  361.    public void reverse() {
  362.       this.negative ^= true;
  363.    }
  364.  
  365.    public static void setPrecision(int var0) {
  366.       precision = var0;
  367.    }
  368.  
  369.    private MyDecimal shift(int var1) {
  370.       int var2 = this.ndot + var1;
  371.       int var3 = var2 > this.len ? var2 : this.len;
  372.       byte[] var4 = new byte[var3];
  373.       System.arraycopy(this.val, 0, var4, 0, this.len);
  374.  
  375.       for(int var5 = this.len; var5 < var3; ++var5) {
  376.          var4[var5] = 0;
  377.       }
  378.  
  379.       MyDecimal var6 = new MyDecimal(var4, var3, this.ndot + var1, this.negative);
  380.       return var6;
  381.    }
  382.  
  383.    public MyDecimal sin() {
  384.       MyDecimal var1 = this.normalizeToPrecision().mod2PI();
  385.       MyDecimal var2 = new MyDecimal(var1);
  386.       MyDecimal var3 = getDelta(precision);
  387.       MyDecimal var5 = new MyDecimal(var1);
  388.       MyDecimal var6 = var1.multiply(var1);
  389.       MyDecimal var7 = new MyDecimal("1");
  390.       boolean var8 = true;
  391.       int var9 = 3;
  392.  
  393.       MyDecimal var4;
  394.       try {
  395.          do {
  396.             var5 = var5.multiply(var6);
  397.             var7 = var7.multiply(new MyDecimal(Integer.toString(var9 - 1))).multiply(new MyDecimal(Integer.toString(var9)));
  398.             var4 = var5.divide(var7);
  399.             var4.negative = var8;
  400.             var2 = var2.add(var4);
  401.             var8 ^= true;
  402.             var9 += 2;
  403.          } while(var4.greater0(var3));
  404.       } catch (Exception var10) {
  405.       }
  406.  
  407.       return var2;
  408.    }
  409.  
  410.    private MyDecimal sub0(MyDecimal var1, boolean var2) {
  411.       int var3 = this.ndot > var1.ndot ? this.ndot : var1.ndot;
  412.       int var4 = this.len - this.ndot;
  413.       if (var1.len - var1.ndot > var4) {
  414.          var4 = var1.len - var1.ndot;
  415.       }
  416.  
  417.       var4 += var3;
  418.       this.normalize2(var3, var4);
  419.       var1.normalize2(var3, var4);
  420.       byte[] var5 = new byte[var4];
  421.       boolean var6 = false;
  422.  
  423.       for(int var7 = var4 - 1; var7 >= 0; --var7) {
  424.          byte var8 = this.val[var7];
  425.          byte var9 = var1.val[var7];
  426.          if (var6) {
  427.             --var8;
  428.          }
  429.  
  430.          var6 = false;
  431.          if (var8 < var9) {
  432.             var8 = (byte)(var8 + 10);
  433.             var6 = true;
  434.          }
  435.  
  436.          var5[var7] = (byte)(var8 - var9);
  437.       }
  438.  
  439.       return new MyDecimal(var5, var4, var3, var2);
  440.    }
  441.  
  442.    public MyDecimal subtract(MyDecimal var1) {
  443.       MyDecimal var2 = new MyDecimal(var1);
  444.       var2.negative ^= true;
  445.       return this.add(var2);
  446.    }
  447.  
  448.    public String toString() {
  449.       MyDecimal var1 = new MyDecimal(this);
  450.       var1.normalize();
  451.       StringBuffer var2 = new StringBuffer(var1.len + 3);
  452.       if (var1.negative) {
  453.          var2.append('-');
  454.       }
  455.  
  456.       if (var1.ndot == 0) {
  457.          var2.append('0');
  458.       }
  459.  
  460.       for(int var3 = 0; var3 < var1.len; ++var3) {
  461.          if (var3 == var1.ndot && var1.ndot != var1.len) {
  462.             var2.append('.');
  463.          }
  464.  
  465.          var2.append((char)(var1.val[var3] + 48));
  466.       }
  467.  
  468.       return var2.toString();
  469.    }
  470. }
  471.